﻿using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Text;

namespace Acoris.Document
{
    public sealed class AcorisMarkdownGenerator
    {
        #region Token Definations


        //---------------------------------------------------------------------------------------------------
        //  AmlTokenizer Sample Data:
        //  <aml>
        //      <header format="diary" encoding="utf8"/>
        //      <interaction>
        //          <action id="123456" source="1" type="IllustateHandbook"/>
        //          <action id="123457" source="2" type="Introduction"/> 
        //      </interaction>
        //      <content>
        //          下列为<format action="123456">Acoris</action>记事本的样例数据
        //      </content>
        //      <resourceDictionary>
        //          <reference type="Interaction" source="Acoris"/>
        //      </resourceDictionary>
        //  </aml>
        //
        //---------------------------------------------------------------------------------------------------

        /// <summary>
        /// 表示终结符的枚举
        /// </summary>
        //enum WordType
        //{
        //    Anyword,                    //
        //    CommentDeclare,             // '!'
        //    Dash,                       // '-'
        //    TagOpen,                    // '<'
        //    TagClose,                   // '>'
        //    DeclareTagClose,            // '/'
        //    EntityCharacter,            // '&'
        //    Equal,                      // '='
        //    Value,                      // '"'
        //    WhiteSpace,                 // '\x20'
        //    NewLine,                    // '\r' '\n'
        //}

        //internal enum TokenType
        //{
        //    BeforeTagName,
        //    AttributeName,
        //    AttributeValue,
        //    Text,
        //    AfterTagName,
        //    Declare
        //}

        //enum DataState
        //{
        //    EmptyState,
            
        //    BeforeTagOpenState,

        //    //下面是注释子状态
        //    CommentDeclareOpenState,
        //    DeclareCloseState,
        //    CommentOpenState,
        //    CommentState,
        //    CommentDeclareCloseState,
        //    CommentCloseState,
            
        //    //下面是正常状态
        //    TagNameState,
        //    AttributeNameState,
        //    AttributeNameCloseState,
        //    AttributeValueState,

        //    TextState,

        //    //
        //    AfterTagNameState,
        //    // 该状态会将进入弹出上一个状态
        //    AfterTagCloseState
        //}

        //internal sealed class Token
        //{
        //    bool _openState;
        //    int _length;
        //    int _offset;
        //    string _source;
        //    TokenType _type;

        //    public Token(TokenType type,string source,int offset,int length)
        //    {
        //        _type = type;
        //        _offset = offset;
        //        _length = length;
        //        _source = source;
        //    }

        //    public bool Close {
        //        get {
        //            return _openState;
        //        }
        //        set {
        //            _openState = value;
        //        }
        //    }

        //    public TokenType Type {
        //        get {
        //            return _type;
        //        }
        //    }

        //    public string Text {
        //        get {
        //            return _source.Substring(_offset, _length);
        //        }
        //    }

        //    public override string ToString()
        //    {
        //        return $"{{{_type},{_source.Substring(_offset, _length)}}}";
        //    }

        //}

        //internal sealed class Lex
        //{
        //    public IEnumerable<Token> Parse(string source)
        //    {
        //        var collection = new List<Token>();
        //        var stateStack = new Stack<DataState>();
        //        var state = DataState.EmptyState;
        //        var offset = 0;

        //        while (offset < source.Length) {
        //            switch (state) {
        //                case DataState.EmptyState:
        //                    // 进入空状态的子状态处理程序
        //                    // offset由子程序提升
        //                    EmptyState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.BeforeTagOpenState:
        //                    // 进入BeforeTagOpenState子状态处理程序
        //                    // offset由子程序提升
        //                    BeforeTagOpenState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.AttributeNameState:
        //                    // 进入AttributeNameState子状态处理程序
        //                    // offset由子程序提升
        //                    AttributeNameState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.AttributeNameCloseState:
        //                    // 进入AttributeNameCloseState子状态处理程序
        //                    // offset由子程序提升
        //                    ReadString(source, ref offset, WordType.Value);
        //                    state = DataState.AttributeValueState;
        //                    break;
        //                case DataState.AttributeValueState:
        //                    // 进入AttributeValueState子状态处理程序
        //                    // offset由子程序提升
        //                    AttributeValueState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.TextState:
        //                    // 进入TextState子状态处理程序
        //                    // offset由子程序提升
        //                    TextState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.AfterTagNameState:
        //                    AfterTagNameState(collection, stateStack, ref offset, ref state, source);
        //                    break;
        //                case DataState.AfterTagCloseState:
        //                    if (stateStack.Count > 0) {
        //                        state = stateStack.Pop();
        //                    }
        //                    else {
        //                        state = DataState.EmptyState;
        //                    }
        //                    offset++;
        //                    break;
        //            }
        //        }

        //        return collection;
        //    }


        //    private WordType Parse(string source, int offset)
        //    {
        //        var ch = source[offset];
        //        switch (ch) {
        //            case '\x20':
        //                return WordType.WhiteSpace;
        //            case '<':
        //                return WordType.TagOpen;
        //            case '>':
        //                return WordType.TagClose;
        //            case '!':
        //                return WordType.CommentDeclare;
        //            case '-':
        //                return WordType.Dash;
        //            case '/':
        //                return WordType.DeclareTagClose;
        //            case '&':
        //                return WordType.EntityCharacter;
        //            case '=':
        //                return WordType.Equal;
        //            case '"':
        //                return WordType.Value;
        //            case '\r':
        //            case '\n':
        //                return WordType.NewLine;
        //            default:
        //                return WordType.Anyword;
        //        }
        //    }

        //    //
        //    // 进入EmptyState子程序
        //    private void EmptyState(List<Token> collection,Stack<DataState> stateStack, ref int offset, ref DataState state,string source) {
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 在未进入任何状态之前的AnyWord均为非法输入
        //                    // TODO: error;
        //                    break;
        //                case WordType.TagOpen:                            
        //                    state = DataState.BeforeTagOpenState;
        //                    offset++;
        //                    return;
        //            }
        //        }
        //    }

        //    //
        //    // 进入TagOpenState子程序
        //    private void BeforeTagOpenState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        // BeforeTagOpenState的后续状态有：
        //        // TagNameState         Anyword 
        //        // CommentDeclareState  !
        //        // AfterTagNameState    /
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入TagName状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    collection.Add(new Token(TokenType.BeforeTagName, source, start, length));
        //                    state = DataState.AttributeNameState;                            
        //                    return;
        //                case WordType.CommentDeclare:
        //                    // 进入Comment处理状态
        //                    CommentDeclareState(collection, stateStack, ref offset, ref state, source);
        //                    state = DataState.EmptyState;
        //                    return; 
        //                case WordType.DeclareTagClose:
        //                    //如果是关闭标签，则清除上一个状态栈
        //                    stateStack.Pop();
        //                    state = DataState.AfterTagNameState;
        //                    offset++;
        //                    return;

        //            }
        //        }
        //    }

        //    //
        //    // 进入AttributeNameState子程序
        //    private void AttributeNameState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入AttributeName状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    collection.Add(new Token(TokenType.AttributeName, source, start, length));
        //                    // 一直移动字符串流直到读取到 '='
        //                    ReadString(source, ref offset, WordType.Equal);
        //                    state = DataState.AttributeNameCloseState;
        //                    return;
        //                case WordType.TagClose:
        //                    state = DataState.TextState;
        //                    offset++;
        //                    return;
        //                case WordType.DeclareTagClose:
        //                    if(CheckState(source,++offset,WordType.TagClose)) {
        //                        state = DataState.EmptyState;
        //                    }
        //                    else {
        //                        // TODO: error
        //                    }
        //                    return;
        //            }
        //        }
        //    }

        //    //
        //    // 进入AttributeValueState子程序
        //    private void AttributeValueState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入AttributeName状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    collection.Add(new Token(TokenType.AttributeValue, source, start, length));
        //                    // 一直移动字符串流直到读取到 '='
        //                    ReadString(source, ref offset, WordType.Value);
        //                    state = DataState.AttributeNameState;
        //                    return;
        //            }
        //        }
        //    }

        //    //
        //    // 进入CommentDeclareState子处理程序
        //    private void CommentDeclareState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        // TODO: 完成CommentState的处理
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入Declare状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    collection.Add(new Token(TokenType.Declare, source, start, length));
        //                    // 判断下一个字符是否为WordType.TagClose
        //                    if (CheckState(source, offset, WordType.TagClose)) {
        //                        state = DataState.EmptyState;
        //                    }
        //                    else {
        //                        // TODO: error
        //                    }
        //                    return;
        //                case WordType.CommentDeclare:
        //                    // 进入Comment处理状态
        //                    break;
        //            }
        //        }
        //    }

        //    //
        //    // 进入TextState子处理程序
        //    private void TextState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        // TextState的后继状态有:
        //        // BeforeTagOpenState
                
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入Text状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    if (length > 0) {
        //                        collection.Add(new Token(TokenType.Text, source, start, length));
        //                    }
        //                    return;
        //                case WordType.TagOpen:
        //                    //在进入TextState之后如果遇到<,则将当前状态压栈，以处理嵌套                           
        //                    stateStack.Push(state);
        //                    state = DataState.BeforeTagOpenState;
        //                    offset++;
        //                    return;
        //            }
        //        }
        //    }

        //    //
        //    // 进入AfterTagNameState子处理程序
        //    private void AfterTagNameState(List<Token> collection, Stack<DataState> stateStack, ref int offset, ref DataState state, string source)
        //    {
        //        // AfterTagName的后继状态有:
        //        // EmptyState   >
        //        // 上一个状态     stateStack不为空的情况下
        //        for (; offset < source.Length; offset++) {
        //            switch (Parse(source, offset)) {
        //                case WordType.Anyword:
        //                    // 进入Text状态
        //                    var start = offset;
        //                    var length = ReadString(source,ref offset);
        //                    collection.Add(new Token(TokenType.AfterTagName, source, start, length));
        //                    return;
        //                case WordType.TagClose:
        //                    state = DataState.AfterTagCloseState;
        //                    return;
        //            }
        //        }
        //    }
        //    //
        //    // 一直移动字符串流直到遇到非AnyWord字符
        //    private int ReadString(string source,ref int offset)
        //    {
        //        var i = 0;
        //        for (; offset < source.Length; offset++, i++) {
        //            if (Parse(source, offset) != WordType.Anyword) {
        //                break;
        //            }
        //        }
        //        return i;
        //    }

        //    //
        //    // 一直移动字符串流直到遇到指定的WordType
        //    private void ReadString(string source,ref int offset,WordType type)
        //    {
        //        for (; offset < source.Length; offset++) {
        //            if (Parse(source, offset) == type) {
        //                break;
        //            }
        //        }
        //    }

        //    //
        //    // 判断字符状态
        //    private bool CheckState(string source,int offset,WordType type)
        //    {
        //        return Parse(source, offset) == type;
        //    }
        //}




        #endregion

        //internal IEnumerable<Token> TestParse(string document)
        //{
        //    var lex = new Lex();
        //    return lex.Parse(document);
        //}
    }
}
